package client

import (
	. "chess_platform/internal/common"
	"chess_platform/models/client"
	"fmt"
)

//主要用于上下分

//上下分
type ContestController struct {
	GrantController
}

func (b *ContestController) URLMapping() {
	b.Mapping("UpdateContestRule", b.UpdateContestRule)

	b.Mapping("ChangeScore", b.ChangeScore)
	b.Mapping("ClearScore", b.ClearScore)
	b.Mapping("ScoreTrans", b.ScoreTrans)
	b.Mapping("SearchScoreTrans", b.SearchScoreTrans)
	b.Mapping("SearchClubScore", b.SearchClubScore)
	b.Mapping("ClubScore", b.ClubScore)
	b.Mapping("ClearFee", b.ClearFee)
	b.Mapping("StatScore", b.StatScore)

	b.Mapping("ClearScoreRecord", b.ClearScoreRecord)
	b.Mapping("ListPlayerWinLost", b.ListPlayerWinLost)

}

// @Title 更新楼层的比赛规则
// @Description 更新楼层的比赛规则
// @Param   id        	    body    int        true      "id"
// @Param   club_id  	    body    int        true      "俱乐部id,不是俱乐部密码"
// @Param   contest_rule  	body    string     true      "比赛规则,json字符串"
// @Success 0 {string} 状态码
// @Failure 400
// @Failure 404
// @router /update-contest-rule [post]
func (b *ContestController) UpdateContestRule() {
	type Params struct {
		Id          int64  `json:"id" valid:"Required"`
		ClubId      int64  `json:"club_id" valid:"Required"`
		ContestRule string `json:"contest_rule"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}

	if !b.ValidParams(&p) {
		return
	}

	ok := client.IsHostByFloorId(p.Id, b.Uid)
	if !ok {
		b.Res.Code = ErrUserForbidden
		b.Res.Msg = "您不是亲友圈创建人或管理员,无权操作"
		b.Response()
		return
	}

	data := map[string]interface{}{
		"contest_rule": p.ContestRule,
	}
	_, err := client.UpdateClubFloor(data, p.Id)
	if err != nil {
		LogClient.Error(b.DatabaseError(err.Error()))
		return
	}
	//亲友圈更新了要发送亲友圈所有成员
	client.BroadCastMsgToLobby(p.ClubId, GenBroadcastMsg(ModuleClub, ActionUpdateFloor, p.Id))
	b.ResponseSuccess()
}

// @Title 调整积分(正数为增加积分,负数为减少积分)
// @Description 调整积分(正数为增加积分,负数为减少积分)
// @Param   club_id  	 body    int     true      "俱乐部id,不是密码"
// @Param   uid     	 body    int     true      "玩家id"
// @Param   score     	 body    int     true      "积分数"
// @Success 0 {string} 状态码
// @Failure 400
// @Failure 404
// @router /change-score [post]
func (b *ContestController) ChangeScore() {
	type Params struct {
		ClubId int64 `json:"club_id" valid:"Required"`
		Uid    int64 `json:"uid" valid:"Required"`
		Score  int64 `json:"score"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}

	if !b.ValidParams(&p) {
		return
	}
	if p.Score == 0 {
		b.ResponseSuccess("请输入有效积分")
		return
	}
	_, role, ok := client.IsClubMemberExist(p.ClubId, b.Uid)
	if !ok || (ok && role != ClubRoleOwner) {
		b.Res.Code = ErrUserForbidden
		b.Res.Msg = "您不是此亲友圈创建人,无权操作"
		b.Response()
		return
	}
	ms, err := client.ListClubMemberScore(p.ClubId, p.Uid)
	if err != nil {
		LogClient.Error(b.SystemError(err.Error()))
		return
	}
	if len(ms) == 0 {
		b.ResponseFail("您操作的玩家不存在,请检查")
		return
	}
	for _, v := range ms {
		if v.FrozeScore != 0 && p.Score < 0 {
			b.ResponseFail("玩家游戏中,不能减少积分")
			return
		} else if v.FrozeScore == 0 && -p.Score > v.Score {
			b.ResponseFail("积分不足,请重新输入")
			return
		}
	}

	err = client.ChangeScore(p.ClubId, p.Uid, p.Score, 0, b.Uid)
	if err != nil {
		LogClient.Error(b.SystemError(err.Error()))
		return
	}
	b.Res.Data = map[string]interface{}{
		"uid":   p.Uid,
		"score": p.Score,
	}
	b.ResponseSuccess("调整积分成功")
	client.BroadCastMsgToLobby(p.ClubId, GenBroadcastMsg(ModuleClub, ActionUpdateScore, p.ClubId), p.Uid)
}

// @Title 清除所有玩家的积分和表情
// @Description 清除所有玩家的积分和表情
// @Param   club_id  	 body    int     true      "俱乐部id,不是密码"
// @Param   uid     	 body    int     false     "玩家id,传0表示清除所有成员的积分和表情,非0表示清除具体某个成员的积分和表情"
// @Param   typ     	 body    int     false     "0-清除积分和表情,1-清除积分,2-清除表情"
// @Success 0 {string} 状态码
// @Failure 400
// @Failure 404
// @router /clear-score [post]
func (b *ContestController) ClearScore() {
	type Params struct {
		ClubId int64 `json:"club_id" valid:"Required"`
		Uid    int64 `json:"uid"`
		Typ    int64 `json:"typ" valid:"Range(0,2)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, role, ok := client.IsClubMemberExist(p.ClubId, b.Uid)
	if !ok || (ok && role != ClubRoleOwner) {
		b.Res.Code = ErrUserForbidden
		b.Res.Msg = "您不是此亲友圈创建人,无权操作"
		b.Response()
		return
	}
	ok, err := client.ClearScore(p.ClubId, b.Uid, p.Uid, p.Typ)
	if err != nil {
		LogClient.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = map[string]interface{}{
		"uid": p.Uid,
		"typ": p.Typ,
	}
	msg := "积分和表情"
	if p.Typ == 1 {
		msg = "积分"
	} else if p.Typ == 2 {
		msg = "表情"
	}
	if p.Uid == 0 { //清除所有的积分
		if ok {
			b.ResponseSuccess(fmt.Sprintf("清除%v成功,部分玩家正在游戏中,不能清除", msg))
			return
		}
		//清除所有玩家的积分成功
		client.BroadCastMsgToLobby(p.ClubId, GenBroadcastMsg(ModuleClub, ActionUpdateScore, 0))
	} else { //清除单个用户的积分
		if ok {
			b.ResponseSuccess(fmt.Sprintf("清除%v失败,玩家正在游戏中,不能清除", msg))
			return
		}
		//清除成功
		client.BroadCastMsgToLobby(p.ClubId, GenBroadcastMsg(ModuleClub, ActionUpdateScore, p.ClubId), p.Uid)
	}
	b.ResponseSuccess(fmt.Sprintf("清除%v成功", msg))
}

// @Title 俱乐部积分操作日志(积分流水)
// @Description 俱乐部积分操作日志(积分流水)
// @Param   page_size    body    int     true       "每页显示数量"
// @Param   page_index   body    int     true       "第几页"
// @Param   club_id  	 body    int     true       "俱乐部id,不是密码"
// @Param   uid  	     body    int     false      "玩家的id,玩家id传0时表示不查某个具体的玩家积分记录,传非0表示查某个具体的玩家的积分记录"
// @Success 0 {string} 状态码
// @Failure 400
// @Failure 404
// @router /score-trans [post]
func (b *ContestController) ScoreTrans() {
	type Params struct {
		ListParams
		ClubId int64 `json:"club_id" valid:"Required"`
		Uid    int64 `json:"uid"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}

	if !b.ValidParams(&p) {
		return
	}
	cs, count, err := client.ListScoreTrans(p.ListParams, p.ClubId, p.Uid)
	if err != nil {
		LogClient.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = cs
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 搜索俱乐部积分操作日志(积分流水)
// @Description 搜索俱乐部积分操作日志(积分流水)
// @Param   page_size    body    int     true       "每页显示数量"
// @Param   page_index   body    int     true       "第几页"
// @Param   club_id  	 body    int     true       "俱乐部id,不是密码"
// @Param   uid  	     body    int     false      "玩家的id,玩家id传0时表示不查某个具体的玩家积分记录,传非0表示查某个具体的玩家的积分记录"
// @Success 0 {string} 状态码
// @Failure 400
// @Failure 404
// @router /search-score-trans [post]
func (b *ContestController) SearchScoreTrans() {
	type Params struct {
		ListParams
		ClubId int64 `json:"club_id" valid:"Required"`
		Uid    int64 `json:"uid"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}

	if !b.ValidParams(&p) {
		return
	}
	cs, count, err := client.ListScoreTrans(p.ListParams, p.ClubId, p.Uid)
	if err != nil {
		LogClient.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = cs
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 俱乐部积分列表
// @Description 俱乐部积分列表
// @Param   page_size    body    int     true       "每页显示数量"
// @Param   page_index   body    int     true       "第几页"
// @Param   club_id  	 body    int     true       "俱乐部id,不是密码"
// @Param   uid  	     body    int     false      "玩家的id,玩家id传0时表示不查某个具体的玩家积分,传非0表示查某个具体的玩家的积分"
// @Success 0 {string} 状态码
// @Failure 400
// @Failure 404
// @router /club-score [post]
func (b *ContestController) ClubScore() {
	type Params struct {
		ListParams
		ClubId int64 `json:"club_id" valid:"Required"`
		Uid    int64 `json:"uid"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	cs, count, err := client.ListClubScore(p.ListParams, p.ClubId, p.Uid)
	if err != nil {
		LogClient.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = cs
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 搜索俱乐部积分列表
// @Description 搜索俱乐部积分列表
// @Param   page_size    body    int     true       "每页显示数量"
// @Param   page_index   body    int     true       "第几页"
// @Param   club_id  	 body    int     true       "俱乐部id,不是密码"
// @Param   uid  	     body    int     false      "玩家的id,玩家id传0时表示不查某个具体的玩家积分,传非0表示查某个具体的玩家的积分"
// @Success 0 {string} 状态码
// @Failure 400
// @Failure 404
// @router /search-club-score [post]
func (b *ContestController) SearchClubScore() {
	type Params struct {
		ListParams
		ClubId int64 `json:"club_id" valid:"Required"`
		Uid    int64 `json:"uid"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	cs, count, err := client.ListClubScore(p.ListParams, p.ClubId, p.Uid)
	if err != nil {
		LogClient.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = cs
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 清除表情统计
// @Description 清除表情统计
// @Param   club_id  	 body    int     true      "俱乐部id,不是密码"
// @Success 0 {string} 状态码
// @Failure 400
// @Failure 404
// @router /clear-fee [post]
func (b *ContestController) ClearFee() {
	type Params struct {
		ClubId int64 `json:"club_id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, role, ok := client.IsClubMemberExist(p.ClubId, b.Uid)
	if !ok || (ok && role != ClubRoleOwner) {
		b.Res.Code = ErrUserForbidden
		b.Res.Msg = "您不是此亲友圈创建人,无权操作"
		b.Response()
		return
	}
	_, err := client.ClearFee(p.ClubId)
	if err != nil {
		LogClient.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess("清除表情成功")
}

// @Title 积分统计
// @Description 积分统计
// @Param   club_id  	 body    int     true      "俱乐部id,不是密码"
// @Success 0 {string} 状态码
// @Failure 400
// @Failure 404
// @router /stat-score [post]
func (b *ContestController) StatScore() {
	type Params struct {
		ClubId int64 `json:"club_id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	ss, err := client.StatScore(p.ClubId)
	if err != nil {
		LogClient.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = ss
	b.ResponseSuccess()
}

// @Title 清除积分记录
// @Description 清除积分记录
// @Param   club_id  	 body    int     true      "俱乐部id,不是密码"
// @Param   id  	     body    int     true      "传0表示清除所有的流水记录,传非0表示清除具体的流水记录的id"
// @Success 0 {string} 状态码
// @Failure 400
// @Failure 404
// @router /clear-score-record [post]
func (b *ContestController) ClearScoreRecord() {
	type Params struct {
		ClubId int64 `json:"club_id" valid:"Required"`
		Id     int64 `json:"id"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, role, ok := client.IsClubMemberExist(p.ClubId, b.Uid)
	if !ok || (ok && role != ClubRoleOwner) {
		b.Res.Code = ErrUserForbidden
		b.Res.Msg = "您不是此亲友圈创建人,无权操作"
		b.Response()
		return
	}
	_, err := client.ClearScoreRecord(p.Id, p.ClubId)
	if err != nil {
		LogClient.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = map[string]interface{}{
		"id": p.Id,
	}
	b.ResponseSuccess("清除记录成功")
}

// @Title 俱乐部成员土豪榜大赢家
// @Description 俱乐部成员土豪榜大赢家
// @Param   page_size    body    int     true       "每页显示数量"
// @Param   page_index   body    int     true       "第几页"
// @Param   club_id  	 body    int     true       "俱乐部id,不是密码"
// @Param   typ  	     body    int     true       "1-大赢家,2-土豪榜"
// @Success 0 {string} 状态码
// @Failure 400
// @Failure 404
// @router /list-win-lost [post]
func (b *ContestController) ListPlayerWinLost() {
	type Params struct {
		ListParams
		ClubId int64 `json:"club_id" valid:"Required"`
		Typ    int64 `json:"typ" valid:"Range(1,2)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	cs, count, err := client.ListPlayerWinLost(p.ListParams, p.ClubId, p.Typ)
	if err != nil {
		LogClient.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = cs
	b.Res.Count = count
	b.ResponseSuccess()
}
